#!/usr/bin/env node

'use strict';

const db = require('../models');
const logger = require('../utils/logger');
const { Sequelize } = require('sequelize');
const fs = require('fs');
const path = require('path');

// 从命令行参数获取选项
const args = process.argv.slice(2);
const forceSync = args.includes('--force');

// 测试数据库连接
async function testConnection() {
  try {
    await db.sequelize.authenticate();
    logger.info('数据库连接测试成功');
    return true;
  } catch (error) {
    logger.error('数据库连接测试失败:', error);
    return false;
  }
}

// 同步所有模型
async function syncModels() {
  try {
    logger.info('开始同步数据库模型...');
    
    if (forceSync) {
      logger.warn('使用force选项，将删除并重建所有表');
      // 先删除SQLite文件（如果存在）
      const dbFile = path.resolve('./database.sqlite');
      if (fs.existsSync(dbFile)) {
        fs.unlinkSync(dbFile);
        logger.info('已删除旧的数据库文件');
      }
      
      // 使用force选项重建所有表
      await db.sequelize.sync({ force: true });
    } else {
      // 使用alter选项修改现有表
      try {
        await db.sequelize.sync({ alter: true });
      } catch (alterError) {
        logger.warn('使用alter选项同步失败，尝试创建缺失的表...');
        // 如果alter失败，尝试只创建缺失的表
        await db.sequelize.sync({ force: false });
      }
    }
    
    logger.info('数据库模型同步成功');
    return true;
  } catch (error) {
    logger.error('数据库模型同步失败:', error);
    logger.error('错误详情:', error.message);
    
    // 如果是SQLite的约束错误，提供解决建议
    if (error.message && error.message.includes('SQLITE_CONSTRAINT')) {
      logger.info('提示：如果遇到SQLite约束错误，可以使用 --force 选项重建数据库');
      logger.info('命令：npm run db:init -- --force');
    }
    
    return false;
  }
}

// 创建默认管理员用户
async function createDefaultAdmin() {
  try {
    // 检查User模型是否存在
    if (!db.User) {
      logger.warn('User模型不存在，跳过创建默认管理员');
      return true;
    }
    
    const adminExists = await db.User.findOne({
      where: { username: 'admin' }
    });
    
    if (adminExists) {
      logger.info('默认管理员用户已存在，跳过创建');
      return true;
    }
    
    // 确保必要字段存在
    const adminData = {
      username: 'admin',
      password: 'admin123', // 会在模型的beforeCreate钩子中进行哈希处理
      role: 'admin',
      status: 'active'
    };
    
    // 检查模型是否需要额外字段
    const userAttributes = db.User.rawAttributes;
    if (userAttributes.name && !userAttributes.name.allowNull) {
      adminData.name = '系统管理员';
    }
    if (userAttributes.email) {
      adminData.email = 'admin@example.com';
    }
    
    await db.User.create(adminData);
    
    logger.info('默认管理员用户创建成功');
    logger.info('用户名: admin');
    logger.info('初始密码: admin123');
    logger.info('请首次登录后立即修改密码！');
    return true;
  } catch (error) {
    logger.error('创建默认管理员用户失败:', error);
    logger.error('错误详情:', error.message);
    return false;
  }
}

// 创建示例销售用户
async function createSampleSalesUsers() {
  try {
    // 检查User模型是否存在
    if (!db.User) {
      logger.warn('User模型不存在，跳过创建示例销售用户');
      return true;
    }
    
    const salesCount = await db.User.count({
      where: { role: 'sales' }
    });
    
    if (salesCount > 0) {
      logger.info('示例销售用户已存在，跳过创建');
      return true;
    }
    
    // 创建3个示例销售用户
    const sampleUsers = [
      { username: 'sales1', password: 'sales123', name: '销售一号', email: 'sales1@example.com' },
      { username: 'sales2', password: 'sales123', name: '销售二号', email: 'sales2@example.com' },
      { username: 'sales3', password: 'sales123', name: '销售三号', email: 'sales3@example.com' }
    ];
    
    for (const user of sampleUsers) {
      try {
        await db.User.create({
          ...user,
          role: 'sales',
          status: 'active'
        });
        logger.info(`创建销售用户: ${user.username}`);
      } catch (userError) {
        logger.warn(`创建销售用户 ${user.username} 失败:`, userError.message);
      }
    }
    
    logger.info('示例销售用户创建完成');
    return true;
  } catch (error) {
    logger.error('创建示例销售用户失败:', error);
    return false;
  }
}

// 主函数
async function init() {
  logger.info('===================================');
  logger.info('开始初始化数据库...');
  if (forceSync) {
    logger.warn('注意：使用--force选项将删除所有现有数据！');
  }
  logger.info('===================================');
  
  // 测试连接
  const connectionSuccess = await testConnection();
  if (!connectionSuccess) {
    logger.error('数据库连接失败，初始化中止');
    process.exit(1);
  }
  
  // 同步模型
  const syncSuccess = await syncModels();
  if (!syncSuccess && !forceSync) {
    logger.error('数据库模型同步失败');
    logger.info('提示：您可以尝试使用 --force 选项强制重建数据库');
    logger.info('命令：npm run db:init -- --force');
    process.exit(1);
  }
  
  // 创建默认用户
  await createDefaultAdmin();
  
  // 创建示例销售用户
  await createSampleSalesUsers();
  
  logger.info('===================================');
  logger.info('数据库初始化完成！');
  logger.info('===================================');
  process.exit(0);
}

// 运行初始化
init().catch(error => {
  logger.error('数据库初始化出错:', error);
  process.exit(1);
}); 